grabs

Updates

Get width/height from GetSystemMetrics()

Fix coordinates for background clearing when redirecting

Backport from svn of this fix

Tweak the click-through handling so active apps get it (but not inactive ones)

Improve explicit drawing and flushing (fixes GtkRuler)

Use the same code path to get a CGContext for both gdk_draw_* and
gdk_cairo_create and make sure we unlockFocus in both cases. This
fixes the broken rendering in GtkRuler. Also use an average of flush
intervals when checking whether we can flush or not, since otherwise
we get too sensitive and block almost all explicit flushes that are
caused by mouse movements for example.

Ensure offscreen windows are not used as non-toplevels

Move the new parts of GdkWindowObject to a private header

Unfortunately the old GdkWindowObject is public and accessed
from macros, etc. So, we publish a limited copy of GdkWindowObject
and use the full one internally when building gdk.

Remove offscreen hooks support

In the new world offscreen windows are not put in the hierarchy, but are
rather toplevels for themselves. Offscreen hooks don't make any sense
in this model.

Make offscreen windows not be in hierarchy

In the new world offscreen windows are a form of toplevels. So,
they don't have a parent, nor do we use the offscreen hooks.

Fix x vs y typo

Misc stuff

CSW Win32 work in progress - builds but does not work yet.

Only add up native subwindow offsets for gdk_window_quartz_get_origin

Limit manual flushing so we don't get hit by quartz' fps limiting

Disable/enable screen updates around process_all_updates to speed up rendering

Get the right event window for non-grabbed windows too

Try to reduce risk of triggering the "beam sync" penalty in quartz

Try to combine consecutive window moves into one

It often happens that we move region A to B and then we move a subset
of B to C. When possible we'd like to replace this with a move from
A directly to C, and a suplimentary move from A to the areas of B not
overwritten by C.

Getting an optimal move combiner seems quite complicated, but this
simple approach gets most of the interesting cases right and isn't
all to complicated.

Free region also if its empty (we're taking ownership now)

Move unnecessary window copies to the right place

This code got placed wrong, it should happen when processing updates
on the impl window so it affects the whole expose, not in begin_updates.

Remove invalid source area from copy in move_region_on_impl

There is no need to copy something that is already invalid and will
be marked as invalid in the destination anyway, so we remove this
area from the region to copy.

Move GdkWindowRegionMove construction/destruction to separate functions

Use clearer names for GdkWindowRegionMove members

queue expose translations after the actual pixel copy

The expose translation is useful for tracking how outstanding
invalid (exposed on server) areas are copied, and how we need to
compensate for that on the client side to redraw the right area.

So, we should queue the translation at the time we actually move
the bits on the server side, not when moving the window on the
client side.

Also, clean up some naming of parameters.

Fix order of outstanding moves in queue

The last added move should be done last, so we need to append moves
not prepend

Make outstanding window moves work with the new model

We now copy outstanding window moves directly on the window and
not to an intermediary pixmap, this means our previous code to
combine window copies was wrong (it relied on each copy not
destroying the source date).

Furthermore, we can't just remove all the update area from the
destination of the outstanding moves, as sometimes things get
copied into that area and then used as the source of another
copy.

We replace the previous window copy combining with a naive
version that just queues each move, just to get things right.
Further work to optimize copies is possible.

Also, we don't remove copy destinations that are used as source
for later copies.

We also clean up the memory management by not having
move_region_on_impl taking ownership of the passed in region.

Don't clear background on no exposure mask if NULL background pixmap set

This is the same as background None in X, i.e. never draw the background.

Don't event process updates for foreign windows

Don't touch private->parent after its been change

The backend reparent may change private->parent, so we must use
the old saved value.

Clear background on expose with no EXPOSURE_MASK

Apps that set no exposure mask rely on the system clearing things
to the window background, so we need to do this ourselves.

Also, don't do this on foreign windows, as they are not controlled
by us. In fact don't do exposes on foreign windows either.

Call backend show() in gdk_window_show even if window is mapped

This is required for the GtkSocket code, as it shows the plug child
even though the current cached state is (wrongly) that its already
mapped.

This makes blink work for non-local case in testsocket.

Refactor background clearing code so we can clear a general region

Be more explicit about when to flush moves

Also makes the non-doublebuffered case work better by flushing before we
call _gdk_windowing_window_process_updates_recurse.

Destroy native children when recursing from a destroy on a virtual window

Native descendants of a virtual children are not automatically destroyed
with the parent as if it was a native window, so we need to handle
the native recursion tracking manually in _gdk_window_destroy_hierarchy()

Only translate native motion events to motion events

Crossing events don't have the device field, which we would like to
pass on, so only do motion events from motion events.

Don't set the background for input only window

This is not allowed and will cause X errors.

Fix assert, it was checking the wrong window

We keep the update freeze count in the impl_window, not in
child windows.

Workaround X11 clipping bug

It turns out that XCopyArea handling of obscured source regions is
buggy. It clears the destination area even outside the GC clip
region. We work around this for the pixmap->window case as that
can happen in gtk+ and is easy to work around.

X Bug report at:
http://lists.freedesktop.org/archives/xorg/2009-February/043318.html

Enable custom event masks for native windows

Some apps really need to set custom event masks on native child windows,
for example emacs sets the event masks with gdk, but then reads out
the raw X events via a filter, so gdk event emulation doesn't work for that.

When we get motion or button events we map back from the event position and
window to the toplevel before doing anything, because a toplevel native window
could e.g. overlap a child window or whatever.

Filter out all native grab/ungrab events with detail INFERIOR

These are generated when we get an implicit grab on a native
child window, and we can't filter them with _has_grab() because
they are sent before the button press event where we detect
the implicit grab.

This makes clicks work in the flash plugin again

Make owner_events grabs work again, use the pointer window, not the event window

Don't ignore all events when inactive, only clicks

Relax the check for ignoring events above the content view

Remove workaround for missing enter events on newly popped up windows

The reason for the issue was that we got entered/exited events for the
title bar buttons. Now we properly ignore those instead.

Remove re-declared variable

Remove unused code and fix some indentation

Button press and release can share the same fill_button_event call

Remove tracking of "current mouse window", this is handled in the common code now

Remove old cursor setting and make it work with client-side windows

Update for latest changes in the common code for grab tracking

Ignore all events if the app is not active

When breaking grabs on deactivation, the unset should be implicit

Use _gdk_display_unset_has_*_grab in break_all_grabs()

Use cooca to convert coordinats from event window to grab window instead of homegrown code

Replace quartz specific keyboard grab code with common code

Cast to avoid warning

Remove unused variable

Use the common pointer grab code instead of tracking it ourselves

Use isKeyWindow instead of isMainWindow for the non-click-through check

Apply non-click-through policy on unfocused windows even if the app is active

Fix coords returned by _gdk_windowing_window_get_pointer, fixes scribble demo

Remove unused remainders from the old implicit grab code

Get implicit grabs working

Leave AppKit events unhandled

Use event_type we already have instead of regetting it

Get the correct root coordinates for events

Return ignoring of native grab/ungrab events when we don't have a grab

It turns out we really have to ignore grab/ungrab events or we'll
report double crossing events when we grab or ungrab.

However, we also can't ignore crossing events from grabs from other clients
as that leads to missed enter/leave events on e.g. alt-tab in metacity.

Fortunately we now track grabs very precisely, so we know with certainty
whether we have a grab at the time (serial) of the native crossing events,
and only if we do we ignore them.

Handle crossing events with subwindows unknown to gdk

If we get crossing events with subwindow unexpectedly being NULL
that means there is a native subwindow that gdk doesn't know about.
We track these and forward them, with the correct virtual window
events inbetween.

This is important to get right, as metacity uses gdk for the frame
windows, but gdk doesn't know about the client windows reparented
into the frame.

enable motion hints - use last sent request

We were using the next request, but there is no guarantee
on is sent. This caused trouble in e.g. the handlebox dragging.

Make sure we report grab broken on window destroy

Report the steady state in gdk_display_pointer_is_grabbed

For instance if we grab the pointer and then check if its grabbed
so that we know to ungrab we don't care that the grab is not
yet active, so report the steady state (i.e. the last grab)

Move implicit grab tracking totally to common code

Don't send crossing events to destroyed windows

New approach for grab tracking code

We try to track the exact grab state, i.e. whats valid on the client
now and whats comming soon via the xserver roundtrip (and when).

Ref windows during _gdk_x11_roundtrip_async

Fix up indentation

Move bitfield in GdkWindowImplX11 to make struct more compact

Only sync the display if creating a native window implicitly

Sync the display when creating a native window.

This is needed because we want to be able to use the xid immediately
even from another process or another connection to the display.

Don't warn about unexpected events on foreign windows

We don't really control these events so its not wrong per se
to have them generate stuff we don't expect.

Update clip region etc, when creating a foreign window

Fix typo in gdk_window_input_shape_combine_region

Make gdk_window_get_toplevel() for CHILD window with root as parent

Having GDK_WINDOW_CHILD windows with root as the parent apparently works,
and metacity uses it. The current gdk_window_get_toplevel() returns the
root window for that, which is wrong, so we check that explicitly.

Don't mess with any events on the root window.

This causes all sorts of weirdness with pointer_over_window
being the rootwindow and then crashing gdk_window_get_toplevel() later.

With this metacity stops crashing madly.

Don't crash if window->parent is NULL

This happens for events on the root window.

Don't recursively set bg none on the parent when e.g. moving children

To avoid drawing the window background of other windows in the area
where the window was we set the bg to none recursively. However, this
is quite costly it the moved window has many siblings. Furthermore, it
is uncommon that siblings overlap, so this cost has little gain.

So, we only set bg None on the parent, which means that there will
be some more flicker in the uncommon case of overlapping siblings.

Simplify do_move_region_bits_on_impl by removing unused arguments

Remove_gdk_pixmap_set_as_backing etc, as this is not used anymore

We don't copy from a window to a pixmap anymore, so all the code
for this can be removed.

Fix warning about XChangeProperty argument type

Remove unused code

Fix warning about wrong type in assignment

Fix warning due to typo

Remove unused label

Avoid warnings about non-handled GDK_EVENT_LAST enum

Fix setting of private->shaped when setting input shape

I.e. it should only be set/unset when setting ShapeBounding.

Don't look for EXPOSE mask set to disable bg none setting

We always set EXPOSE in the client-side-windows world, so this
doesn't make sense anymore.

Fix typos in X11 details of new OSX APIs

Don't ignore native CROSSING_GRAB/UNGRAB events

These are sent when someone else grabs the pointer, and we don't
want to miss these expose events. For instance, we missed enter
and leave events on alt-tab.

There were some issues with these wrt out-of-sync grab information
in the client, but that should now be handled. So, it should work
or at least be fixable if we find some bug.

Track pointer grabs on Xserver time

After a successful grab/ungrab we wait for an xserver
roundtrip until we change the tracked grab in GdkDisplay.
This way that data is always up-to-date wrt events comming in.